{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Credits: https://github.com/bansalkanav/Machine_Learning_and_Deep_Learning/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Object Oriented Programming\n",
    "\n",
    "In this Notebook, we will cover the concept of:\n",
    "1. Class - Blueprint of an Object\n",
    "```\n",
    "class ClassName:\n",
    "    - Properties (Variables)\n",
    "    - Constructor (It is a special method)\n",
    "    - Behaviours (Methods - Ways to update the properties)\n",
    "```\n",
    "2. Object - Real world entity\n",
    "```\n",
    "obj = ClassName()\n",
    "obj.properties\n",
    "obj.behaviours()\n",
    "```\n",
    "3. Constructor\n",
    "    - With no parameter\n",
    "    - With one or more parameters\n",
    "4. Types of Variables\n",
    "    - Instance Variable\n",
    "    - Class Variable\n",
    "    - Local Variable\n",
    "5. Types of Methods\n",
    "    - Instance Methods\n",
    "    - Class Methods\n",
    "    - Static Methods\n",
    "6. Access Modifiers\n",
    "    - Public\n",
    "    - Private\n",
    "    - Protected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Syntax\n",
    "\n",
    "```\n",
    "class ClassName:\n",
    " - Variables\n",
    " - Methods\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T06:29:51.398848Z",
     "start_time": "2018-05-31T06:29:51.391831Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my First Class.\n",
      "Help on class MyFirstClass in module __main__:\n",
      "\n",
      "class MyFirstClass(builtins.object)\n",
      " |  This is my First Class.\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class MyFirstClass:\n",
    "    '''This is my First Class.'''\n",
    "    pass\n",
    "    \n",
    "print(MyFirstClass.__doc__)\n",
    "help(MyFirstClass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object Creation (Instantiation)\n",
    "\n",
    "```\n",
    " object_name = ClassName()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T00:44:40.430601Z",
     "start_time": "2018-05-31T00:44:40.426591Z"
    }
   },
   "outputs": [],
   "source": [
    "my_ref_var = MyFirstClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Variables and Methods of Class\n",
    "\n",
    "```\n",
    " object_name.variables\n",
    " object_name.methods()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T06:59:54.975039Z",
     "start_time": "2018-05-31T06:59:54.968021Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable\n",
      "Method Called\n"
     ]
    }
   ],
   "source": [
    "class HelloWorld:\n",
    "    '''This is my Hello World class'''\n",
    "    class_variable = 'Variable'\n",
    "    def display(self):\n",
    "        print('Method Called')\n",
    "        \n",
    "h = HelloWorld()\n",
    "\n",
    "print(h.class_variable)\n",
    "\n",
    "h.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructor\n",
    "\n",
    "- It is a special method\n",
    "- Get called at object initialization automatically \n",
    "- Used for initializing the variables \n",
    "- Returns `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor called.\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "class HelloWorld:\n",
    "    '''This is my Hello World class'''\n",
    "    \n",
    "    def __init__(self):\n",
    "        print(\"Constructor called.\")\n",
    "    \n",
    "    def display(self):\n",
    "        print('Hello World')\n",
    "        \n",
    "h = HelloWorld()\n",
    "\n",
    "h.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructor With Multiple Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T07:33:46.776383Z",
     "start_time": "2018-05-31T07:33:46.748825Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: abc, RollNo: 1, Marks: 90\n",
      "Name: xyz, RollNo: 2, Marks: 80\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "INSTANCE variable should be used using 'self', \n",
    "whether inside constructor or method\n",
    "'''\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, name, rno, marks):\n",
    "        self.name = name\n",
    "        self.rno = rno\n",
    "        self.marks = marks\n",
    "    def display(self):\n",
    "        print('Name: {}, RollNo: {}, Marks: {}'.\\\n",
    "              format(self.name, self.rno, self.marks))\n",
    "\n",
    "    \n",
    "s1 = Student('abc', 1, 90)\n",
    "\n",
    "s1.display()\n",
    "\n",
    "s2 = Student('xyz', 2, 80)\n",
    "\n",
    "s2.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'abc', 'rno': 1, 'marks': 90}\n"
     ]
    }
   ],
   "source": [
    "print(s1.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of Variables (Properties)\n",
    "\n",
    "1. Instance Variable \n",
    "    - Object level Variable\n",
    "    - The value of the variable varies from object to object, such type of variables are instance variables  \n",
    "\n",
    "\n",
    "2. Static Variable \n",
    "    - Class level Variable\n",
    "    - These variable are same for all object  \n",
    "\n",
    "\n",
    "3. Local Variable \n",
    "    - Method level Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Instance Variable\n",
    "\n",
    "**How to access?**\n",
    "1. Inside class\n",
    "    - self.variable_name  \n",
    "    \n",
    "    \n",
    "2. Outside class\n",
    "    - obj_name.variable_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T07:39:52.774447Z",
     "start_time": "2018-05-31T07:39:52.767429Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: abc, RollNo: 1, Marks: 90\n",
      "Name: xyz, RollNo: 2, Marks: 80\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, rno, marks):\n",
    "        self.name = name\n",
    "        self.rno = rno\n",
    "        self.marks = marks\n",
    "    \n",
    "    def display(self):\n",
    "        print('Name: {}, RollNo: {}, Marks: {}'.\\\n",
    "              format(self.name, self.rno, self.marks))\n",
    "      \n",
    "    \n",
    "s1 = Student('abc', 1, 90)\n",
    "\n",
    "s1.display()\n",
    "\n",
    "s2 = Student('xyz', 2, 80)\n",
    "\n",
    "s2.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Static Variable\n",
    "\n",
    "**How to access?**\n",
    "1. Inside class\n",
    "    - ClassName.variable_name  \n",
    "    or\n",
    "    - self.variable_name\n",
    "    \n",
    "    \n",
    "2. Outside class\n",
    "    - ClassName.variable_name  \n",
    "    or\n",
    "    - obj_name.variable_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T07:54:33.058179Z",
     "start_time": "2018-05-31T07:54:33.051659Z"
    }
   },
   "outputs": [],
   "source": [
    "class Student:\n",
    "    college = 'LMN'\n",
    "    def __init__(self, name, rno, marks):\n",
    "        self.name = name\n",
    "        self.rno = rno\n",
    "        self.marks = marks\n",
    "    \n",
    "    def display(self):\n",
    "        print('Name: {}, RollNo: {}, Marks: {},'.\n",
    "              format(self.name, self.rno, self.marks), end=' ')\n",
    "        print('College:', self.college)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T07:54:33.058179Z",
     "start_time": "2018-05-31T07:54:33.051659Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: abc, RollNo: 1, Marks: 90, College: LMN\n",
      "Name: xyz, RollNo: 2, Marks: 80, College: LMN\n",
      "Name: lmn, RollNo: 3, Marks: 100, College: LMN\n",
      "LMN\n"
     ]
    }
   ],
   "source": [
    "s1 = Student('abc', 1, 90)\n",
    "\n",
    "s1.display()\n",
    "\n",
    "s2 = Student('xyz', 2, 80)\n",
    "\n",
    "s2.display()\n",
    "\n",
    "s3 = Student('lmn', 3, 100)\n",
    "\n",
    "s3.display()\n",
    "\n",
    "print(Student.college)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T07:56:03.118244Z",
     "start_time": "2018-05-31T07:56:03.115236Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: abc, RollNo: 1, Marks: 90, College: XYZ\n",
      "Name: xyz, RollNo: 2, Marks: 80, College: LMN\n",
      "Name: lmn, RollNo: 3, Marks: 100, College: LMN\n"
     ]
    }
   ],
   "source": [
    "# # Lets try to change the STATIC variable using s1\n",
    "\n",
    "s1.college = 'XYZ'\n",
    "\n",
    "s1.display()\n",
    "\n",
    "s2.display()\n",
    "\n",
    "s3.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: abc, RollNo: 1, Marks: 90, College: XYZ\n",
      "Name: xyz, RollNo: 2, Marks: 80, College: ABCD\n",
      "Name: lmn, RollNo: 3, Marks: 100, College: ABCD\n"
     ]
    }
   ],
   "source": [
    "# # Lets try to change the STATIC variable using Class Name\n",
    "\n",
    "Student.college = 'ABCD'\n",
    "\n",
    "s1.display()\n",
    "\n",
    "s2.display()\n",
    "\n",
    "s3.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Local Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-31T08:01:15.905176Z",
     "start_time": "2018-05-31T08:01:15.900162Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "class Test:\n",
    "    def m1(self):\n",
    "        x = 10\n",
    "        print(x)\n",
    "    def m2(self):\n",
    "        y = 20\n",
    "        print(y)\n",
    "        \n",
    "t = Test()\n",
    "t.m1()\n",
    "t.m2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type of Methods (Behaviours)\n",
    "\n",
    "1. Instance Method\n",
    "    - Instance methods take `self` parameter that points to the object instance. \n",
    "    - It can be used to modify the instance state.\n",
    "2. Class Method\n",
    "    - Instead of accepting a self parameter, class methods take a `cls` parameter that points to the class—and not the object instance—when the method is called.\n",
    "    - Because the class method only has access to this cls argument, it can’t modify object instance state. That would require access to self. However, class methods can still modify class state that applies across all instances of the class.\n",
    "3. Static Method\n",
    "    - This type of method takes neither a self nor a cls parameter (but of course it’s free to accept an arbitrary number of other parameters).\n",
    "    - Therefore a static method can neither modify object state nor class state. Static methods are restricted in what data they can access - and they’re primarily a way to namespace your methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test:\n",
    "    class_variable = 'Test'\n",
    "    def __init__(self, n, a):\n",
    "        self.name = n\n",
    "        self.age = a\n",
    "        \n",
    "    def display(self):\n",
    "        print('*'*20)\n",
    "        print(\"Name: \", self.name)\n",
    "        print(\"Age: \", self.age)\n",
    "        print('*'*20)\n",
    "        \n",
    "    @classmethod\n",
    "    def class_method(cls):\n",
    "        print(\"This is a class method!\")\n",
    "        print(cls.class_variable)\n",
    "        \n",
    "    @staticmethod\n",
    "    def static_method():\n",
    "        print(\"This is a static method!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "********************\n",
      "Name:  Kanav\n",
      "Age:  10\n",
      "********************\n"
     ]
    }
   ],
   "source": [
    "obj = Test('Kanav', 10)\n",
    "\n",
    "obj.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a class method!\n",
      "Test\n",
      "This is a class method!\n",
      "Test\n"
     ]
    }
   ],
   "source": [
    "obj.class_method()\n",
    "\n",
    "Test.class_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method!\n",
      "This is a static method!\n"
     ]
    }
   ],
   "source": [
    "obj.static_method()\n",
    "\n",
    "Test.static_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access Modifiers\n",
    "\n",
    "Access modifiers are used to restrict the access to the variables and methods. Most programming languages has three forms of access modifiers - **Public, Private and Protected**.\n",
    "\n",
    "Python uses `_` symbol to determine the access control for a specific data member or a member function of a class.\n",
    "\n",
    "Access specifiers in Python have an important role to play in securing data from unauthorized access and in preventing it from being exploited.\n",
    "\n",
    "1. Public\n",
    "    - Members defined as public will be accessible from any part of the program. \n",
    "    - All data members and member functions of a class are public by default.\n",
    "2. Private\n",
    "    - The members of a class that are declared private are accessible within the class only.\n",
    "    - Private access modifier is the most secure access modifier. \n",
    "    - Data members of a class are declared private by adding a double underscore `__` symbol before the data member of that class. \n",
    "3. Protected\n",
    "    - Members of a class that are declared protected are only accessible to a class derived from it.\n",
    "    - Data members of a class are declared protected by adding a single underscore `_` symbol before the data member of that class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Boy:\n",
    "    def __init__(self, name, age):\n",
    "        # Public Data Member\n",
    "        self.name = name\n",
    "        # Private Data Member\n",
    "        self.__age = age\n",
    "        \n",
    "    def display(self):\n",
    "        print(self.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kanav\n"
     ]
    }
   ],
   "source": [
    "obj_1 = Boy('Kanav', 100)\n",
    "\n",
    "obj_1.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kanav\n"
     ]
    }
   ],
   "source": [
    "# As you know that we can access the class members by using object name\n",
    "\n",
    "print(obj_1.name)\n",
    "\n",
    "# print(obj_1.__age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example-1 : Create a `Bottle` class with `color` and `capacity` properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bottle:\n",
    "    \n",
    "    def __init__(self, col, cap):\n",
    "        self.color = col\n",
    "        self.capacity = cap\n",
    "    \n",
    "    def details(self):\n",
    "        print(\"Color of the bottle is {}\".format(self.color))\n",
    "        print(\"Capacity of the bottle is {} Litres\".format(self.capacity))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "purple_bottle = Bottle(\"Purple\", 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color of the bottle is Purple\n",
      "Capacity of the bottle is 5 Litres\n"
     ]
    }
   ],
   "source": [
    "purple_bottle.details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color of the bottle is Red\n",
      "Capacity of the bottle is 1 Litres\n"
     ]
    }
   ],
   "source": [
    "red_bottle = Bottle(\"Red\", 1)\n",
    "\n",
    "red_bottle.details()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example-2 : Create a `Human` class with some properties and methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Human:\n",
    "    # age, Gender, Name\n",
    "    def __init__(self, a, g, n):\n",
    "        self.age = a\n",
    "        self.gender = g\n",
    "        self.name = n\n",
    "    def print_details(self):\n",
    "        print(self.name, self.age, self.gender)\n",
    "    def update_age(self, a):\n",
    "        self.age = a\n",
    "        print(\"Age Updated Successfuly\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_1 = Human(100, 'Male', 'Kanav')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kanav 100 Male\n"
     ]
    }
   ],
   "source": [
    "obj_1.print_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_2 = Human(200, 'Male', 'Rahul')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul 200 Male\n"
     ]
    }
   ],
   "source": [
    "obj_2.print_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age Updated Successfuly\n"
     ]
    }
   ],
   "source": [
    "rahul.update_age(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul 20 Male\n"
     ]
    }
   ],
   "source": [
    "rahul.print_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example-3 : Create a `BankAccount` class with some properties and methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your implementation here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q.1- Create a circle class and initialize it with radius. Make two methods getArea and getCircumference inside this class.\n",
    "\n",
    "Q.2- Create a Student class and initialize it with name and roll number. Make methods to :\n",
    "1. Display - It should display all informations of the student.\n",
    "2. setAge - It should assign age to student \n",
    "3. setMarks - It should assign marks to the student.\n",
    "\n",
    "Q.3- Create a Temprature class. Make two methods :\n",
    "1. convertFahrenheit - It will take celsius and will print it into Fahrenheit.\n",
    "2. convertCelsius - It will take Fahrenheit and will convert it into Celsius.\n",
    "\n",
    "Q.4- Create a class MovieDetails and initialize it with artistname,Year of release and ratings .\n",
    "Make methods to\n",
    "1. Display-Display the details.\n",
    "2. Add- Add the movie details.\n",
    "\n",
    "Q.5- Create a class Expenditure and initialize it with salary,savings, category , total expenditure.Make the following methods.\n",
    "1. Add expenditure according to category .\n",
    "2. Calculate total expenditure.\n",
    "3. Calculate per day and monthly expenditure.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
